Performing vector multiplication

ABSTRACT

A method includes receiving packed data corresponding to pixel components to be processed at a graphics pipeline. The method includes unpacking the packed data to generate floating point numbers that correspond to the pixel components. The method also includes routing each of the floating point numbers to a separate lane of the graphics pipeline. Each of the floating point numbers are to be processed by multiplier units of the graphics pipeline.

I. FIELD OF THE DISCLOSURE

The present disclosure relates generally to computer processing, and more specifically, performing vector multiplication.

II. BACKGROUND

In computer graphics, normal mapping (also known as bump mapping) is a technique to provide details of a surface of a three-dimensional object. In normal mapping, calculations, such as dot products, may be performed at a pixel level to provide the details of the surface of the three-dimensional object. A graphics pipeline may repeatedly perform these calculations.

III. SUMMARY OF THE DISCLOSURE

In a particular embodiment, a method includes receiving packed data corresponding to pixel components to be processed at a graphics pipeline. The method includes unpacking the packed data to generate floating point numbers that correspond to the pixel components. The method also includes routing each of the floating point numbers to a separate lane of the graphics pipeline. Each of the floating point numbers is processed by a multiplier unit of the graphics pipeline.

In another particular embodiment, a method includes receiving packed data corresponding to pixel components to be processed at a graphics pipeline. The method includes receiving a mapping instruction. The method also includes unpacking the packed data in response to receiving the mapping instruction to generate first floating point numbers that correspond to the pixel components. The method further includes routing each of the first floating point numbers to a separate lane of the graphics pipeline via a set of mux units. Each of the first floating point numbers is processed by a multiplier unit of the graphics pipeline. The method includes routing each of second floating point numbers to the separate lanes of the graphics pipeline via the set of mux units. Each of the second floating point numbers is processed by an aligner unit of the graphics pipeline.

In another particular embodiment, a system includes an unpack unit to receive packed data corresponding to pixel components and to unpack the packed data to generate floating point numbers that correspond to the pixel components. The pixel components including a red component, a green component, and a blue component. The system includes a first plurality of mux units to selectively route each of the floating point numbers to a separate lane of a graphics pipeline. The floating point numbers are processed by multiplier units of the graphics pipeline.

These and other advantages and features that characterize embodiments of the disclosure are set forth in the claims annexed hereto and forming a further part hereof. However, for a better understanding of the disclosure, and of the advantages and objectives attained through its use, reference should be made to the drawings and to the accompanying descriptive matter in which there are described exemplary embodiments of the disclosure.

IV. BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram of a system to map normal vectors from tangent space to camera space;

FIG. 2 is a block diagram of a system to calculate a scaled dot product;

FIG. 3 is a first flow diagram of a method to calculate a scaled dot product;

FIG. 4 is a second flow diagram of a method to calculate a scaled dot product; and

FIG. 5 is a general diagram of a computing system.

V. DETAILED DESCRIPTION

Normal mapping is a technique that may be used when generating three-dimensional computer graphics to generate the details of a surface of an object. Normal mapping uses data from a normal map in which red, green and blue channels of the normal map image represents x, y and z components of a normal vector at each texture pixel (“texel”). Normal mapping uses normal vectors, i.e., vectors that are perpendicular to a surface, for each pixel.

In normal mapping, the normal vectors used in per-pixel lighting calculations may be taken from the normal map. To perform the lighting calculations, it may be advantageous to have the normal vectors represented as floating point vectors. One advantage of using floating point vectors is that the lighting calculations may be performed more accurately, resulting in more realistic looking textures. Normal vectors are typically loaded into memory from the normal map as packed (i.e., compressed) colors, in which each color channel is represented by an eight-bit unsigned integers. Because a human eye can generally resolve a maximum of 2⁸ variations in a particular color, eight-bit unsigned integers may be used to represent each color channel. For example, a data representation of a twenty-four bit color pixel may include an eight-bit field representing red, an eight-bit field representing green, and an eight-bit field representing blue. The eight-bit unsigned integers may be converted to floating point values before performing the lighting calculations.

To convert the eight-bit unsigned integers to floating point numbers, each eight-bit unsigned integer may be multiplexed (“muxed”) into the most significant eight-bits in a floating point pipeline. The result of multiplexing an eight-bit unsigned integer into the most significant eight-bits of a floating point number is a non-normalized number that ranges from a value of 0.0 to a value of 1.0. Because the normal vectors are typically normalized before they are stored in the normal map (i.e., each normal vector is a unit vector with a length of 1), each of the x, y and z values of each normal vector may range between a value of −1.0 to a value of +1.0. Thus, the non-normalized number that ranges from a value of 0.0 to a value of 1.0 may be scaled to normalize the intermediate result. To scale the intermediate result from the range 0.0 to 1.0 to the range −1.0 to +1.0, the intermediate result may be multiplied by two (i.e., the intermediate result would be from 0.0 to 2.0) and then the constant 1.0 may be subtracted.

Each normal vector is initially defined in a coordinate system called tangent space (also known as texture space). The coordinates and vectors in tangent space are relative to an origin on a plane of the normal map. In camera space, i.e., a coordinate system of a three-dimensional scene, vertices and mapped vectors are relative to the camera rather than to the normal map. To map a particular texture on to a surface of the three-dimensional scene, the lighting calculations may be performed using the normal vectors in the tangent space and the view, light and other vectors in the camera space. Therefore, either the view, light and other vectors in camera space may be converted to tangent space vectors, or the tangent space vectors from the normal map may be converted to camera space vectors. This disclosure describes converting normal vectors in tangent space to mapped normal vectors in camera space. Converting the normal vectors in tangent space to mapped normal vectors in camera space may involve converting (i.e., unpacking) the eight-bit unsigned integers to floating point numbers, scaling the floating point numbers, and multiplying (i.e., multiplying vectors and summing the results is known as a dot product operation) the scaled floating point numbers by a tangent space conversion matrix to create the normal vectors in camera space.

For example, the following vector multimedia extension (vmx) instructions may be used to convert normal vectors in tangent space to mapped normal vectors in camera space. In this example, vert1, vert2, and vert3 are the three vertices of a triangle (i.e., a geometric primitive) and u1, v1, u2, v2, u3, v3 are u and v coordinates for the normal map that align with the 3 vertices.

vec32.x=vert3→x−vert2→x;

vec32.y=vert3→y−vert2→y;

vec32.z=vert3→z−vert2→z;

vec12.x=vert1→x−vert2→x;

vec12.y=vert1→y−vert2→y;

vec12.z=vert1→z−vert2→z;

dv32=u3−u2; du12=u1−u2;

dv32=v3−v2; dv12=u1−v2;

Mtex=1.0/((du32*dv12)−(du12*dv32));

The tangent space conversion matrix may be a 3×3 matrix that includes vectors TanT, BinormB and NormN:

TanT.x=((dv12*vec32.x)−(dv32*vec12.x))*Mtex;

TanT.y=((dv12*vec32.y)−(dv32*vec12.y))*Mtex;

TanT.z=((dv12*vec32.z)−(dv32*vec12.z))*Mtex;

BinormB.x=((−du12*vec32.x)+(du32*vec12.x))*Mtex;

BinormB.y=((−du12*vec32.y)+(du32*vec12.y))*Mtex;

BinormB.z=((−du12*vec32.z)+(du32*vec12.z))*Mtex;

NormN=v3normalize(v3cross(TanT, BinormB));

For each of the three (i.e., red, green, blue) normal vectors that represents a pixel, the normal vector is unpacked and scaled:

tempA=(normmap_bits[(ui*3)+(vi*texmapx*3)]127.0)−1.0;

tempB=(normmap_bits[(ui*3)+(vi*texmapx*3)+1]/127.0)−1.0;

tempC=(normmap_bits[(ui*3)+(vi*texmapx*3)+2]/127.0)−1.0;

The scaled normal vectors may be multiplied by each row of the tangent space conversion matrix:

normvec.x=TanT.x*tempa+BinormB.x*tempb+NormN.x*tempc;

normvec.y=TanT.y*tempa+BinormB.y*tempb+NormN.y*tempc;

normvec.z=TanT.z*tempa+BinormB.z*tempb+NormN.z*tempc;

The 3×3 matrix made up of the vectors TangentT, BinormB, and NormN is transposed to create the tangent space conversion matrix, which is made up of the vectors TBNx, TBNy, TBNz.

[TBNx, TBNy, TBNz]=transpose[TanT, BinormB, NormN];

A dot product operation is performed using each of the rows of the tangent space conversion matrix

Normal.x=dot3(TBNx, NormalFromMap)

Normal.y=dot3(TBNy, NormalFromMap)

Normal.z=dot3(TBNz, NormalFromMap)

Thus, the normal vector unpack, scaling, and tangent space conversion may be performed on a per-pixel basis. Each step of unpack, scale, and dot product, represents a dependent instruction chain that may introduce pipeline delay due to read-after-write dependency conditions. For example, when an unpack operation uses 4 cycles, a scaling operation (i.e., a multiple and an add) uses 4 cycles, and a dot product uses 6 cycles, the number of processing cycles to convert a normal vector from tangent space to camera space may utilize 14 cycles.

By merging the unsigned integer to vector floating point unpack operation and scale operation with a dot product operation, a component of a normal vector may be converted from tangent space to camera space in one pass through the graphics pipeline. By doing so, the number of processing cycles used to perform the conversion may be significantly reduced. For example, the total number of processing cycles to convert a component of a normal vector from tangent space to camera space may be reduced from 14 cycles to 6 cycles.

Referring now to FIG. 1, a block diagram of a system to map normal vectors from tangent space to camera space is depicted and generally designated 100. The system 100 includes a graphics pipeline 108, multiplexers (“mux units”) 110, and an unpack unit 112. The system 100 may be used to map normal vectors from tangent space 102 to mapped vectors in camera space 106.

The graphics pipeline 108 may include multiple processing lanes, such as the first lane 114, the second lane 115, the third lane 116, and the fourth lane 117. Each of the lanes 114-117 may include multiple processing units (not shown). For example, the processing units in each of the lanes 114-117 may include an adder unit (i.e., to add floating point numbers), a multiplier unit (i.e. to multiply floating point numbers), an aligner unit (i.e., to align floating point numbers), a normalize unit (i.e., to normalize floating point numbers), a rounding unit (i.e., to round off floating point numbers), a compressor unit (i.e., to add more than two numbers), a dot product unit (i.e., to calculate a dot product of two vectors or a vector and a row of a matrix), another unit capable of performing a mathematical operation, or any combination thereof. Each of the lanes 114-117 may operate substantially in parallel.

The unpack unit 112 may unpack unsigned integers and convert the unsigned integers to floating point numbers for processing by the graphics pipeline 108. The mux units 110 may include multiplexer units to select operands to send to processing units of the lanes 114-117.

The normal vectors in tangent space 102 depict normal vectors that are perpendicular to a plane. To provide a textured surface to a spherical object 104, the normal vectors in tangent space 102 may be wrapped around the spherical object 104 to create the mapped vectors in camera space 106.

In operation, the unpack unit 112 may receive normal vectors 120 (i.e., values that represent the normal vectors in tangent space 102) and a conversion matrix 121. The unpack unit 112 may unpack the normal vectors 120 and convert the components of the normal vectors 120 to floating point numbers (not shown). The mux units 110 may select portions of the floating point numbers and send the portions to processing units in the lanes 114-117. The graphics pipeline 108 may output the transformed vectors 122 (i.e., values that represent the mapped vectors in camera space 106).

Thus, by adding the unpack unit 112 and the mux units 110 before the graphics pipeline 108, the normal vectors 120 may be rapidly converted into the transformed vectors 123. For example, the unpack unit 112 and the mux units 110 may enable the graphics pipeline 108 to perform the conversion of the normal vectors 120 more than fifty percent faster than if the unpack unit 112 and the mux units 110 were not used.

Referring now to FIG. 2, a block diagram of a system to calculate a scaled dot product is depicted and generally designated 200. The system 200 includes a graphics pipeline 202, a summing stage 204, an initial stage 206, and a register file 208. The system 200 may be part of a graphics processing unit.

The register file 208 may include two or more registers, such as registers 220 and 221. The registers 220-221 may be used to store numbers, such as operands, results from performing operations on the numbers, memory addresses (e.g., pointers), etc. For example, each of the registers 220-221 may store words of an array that represents a vector or a row of a matrix. To illustrate, the register 220 may be used to store numbers that represent a vector A (e.g., a normal vector) and the register 221 may be used to store a row of a matrix (e.g., a vector B). Each word may be a fixed sized group of bits that are handled together by the system 200. Each word of the registers 220-221 may have a word size, such as 16, 32 or 64 bits.

The initial stage 206 includes an unpack unit 212, a bus 210, and multiplexer units (referred to as “mux units”), such as the mux units 240, 241, 242, 243, 244, 245, 246, and 247. The unpack unit 212 may unpack packed data (e.g., the content of register 220) that represents a pixel into floating point numbers. For example, the register 220 may include three eight-bit words, Ax, Ay, and Az, that represent a red, a green, and a blue value of a pixel. The unpack unit 212 may unpack each eight-bit word to generate a floating point number for processing by the graphics pipeline 202. The bus 210 may include paths (not shown) between the register file 208, the initial stage 206, the graphics pipeline 202, and the summing stage 204. For example, the paths may enable the bus 210 to route contents of the registers 220-221 to portions of the initial stage 206. The mux units 240-247 may be used to select operands from the contents of the register file 208 for the next stage, i.e., the graphics pipeline 202. For example, the mux units 240-247 may be used to select operands of the contents of the registers 220-221 for use by arithmetic units of the graphics pipeline 202.

The graphics pipeline 202 may include various arithmetic units, such as multiplier units 254, 255, 256, and 257 (e.g., to multiple two operands), aligner units 250, 251, 252, and 253 (e.g., to align floating point numbers prior to an add operation), add units 260, 261, 262, and 263 (e.g., to add two numbers together), normalize units 264, 265, 266, and 267 (e.g., to scale a number by changing a range of the number), rounding units 270, 271, 272, and 273 (e.g., to round off numbers), or any combination thereof. The graphics pipeline 202 may be structured into lanes that operate substantially in parallel on each word of the contents of the registers 220-221. For example, the graphics pipeline 202 may include a first lane 234, a second lane 235, a third lane 236, and a fourth lane 237. The first lane 234 may operate on a first word of the contents of the registers 220-221 as selected by the initial stage 206. The second lane 235 may operate on a second word of the contents of the registers 220-221 as selected by the initial stage 206. The third lane 236 may operate on a third word of the contents of the registers 220-221 as selected by the initial stage 206. The fourth lane 237 may operate on a fourth word of the contents of the registers 220-221 as selected by the initial stage 206. For example, the first lane 234 may compute a red (“R”) component of a pixel, the second lane 235 may compute a green (“G”) component of the pixel, and the third lane 236 may compute a blue (“B”) component of the pixel. In the context of a computer graphics system that is computing three colors for each pixel (i.e., RGB), the fourth lane may not be used.

The summing stage 204 may be used to perform a dot product operation (e.g., a vector multiply and a vector add) on an output of the graphics pipeline 202. The summing stage 204 may include various arithmetic units, such as aligners 280-283 (e.g., to align floating numbers for an add/compress operation), a 4:2 compressor unit 284 (e.g., to add two pairs of numbers to produce a pair of intermediate results), an adder unit 285 (e.g., to add the pair of intermediate results to produce a final number), and a normalize unit 286 (e.g., to normalize the final number). An output of the summing stage 204 may be stored in a result register (not shown) of the register file 208.

In operation, words representing a vector A (e.g., a normal vector) may be stored in the register 220. For example, words Ax, Ay, Az, and Aw may be stored in the register 220. The words Ax, Ay, and Az may represent a directional component of the vector in a three-dimensional space or the red, green and blue components of a pixel. The word Aw may represent a velocity component of the vector.

Words representing a vector B may be stored in the register 221. For example, floating point words Bx, By, Bz, and Bw may be stored in the register 221. To illustrate, the words Bx, By, Bz, and Bw may be a row of a tangent space conversion matrix. The vector A and the vector B may be stored at the registers 220-221 by a computer graphics system (not shown) to enable the system 200 to transform the vector A from a normal vector in tangent space to a normal vector in camera space.

The unpack unit 212 may determine that a normal mapping (“nmap”) instruction 214 is to be executed on the contents of registers 220-221 (i.e., vector A and vector B). In response, the unpack unit 212 may convert each word of the content of register 220 into a floating point number. For example, the unpack unit 212 may set an implicit bit and an unbiased exponent to zero and multiplex in a word of the vector A into a most significant fraction bits. To illustrate, the unpack unit 212 may convert a hexadecimal word 0b00110011 to a floating point equivalent, i.e., 0.00110011×2⁰.

To map a normal vector from tangent space to camera space, a scaled dot product may be calculated. A dot product is calculated as dot3=(Ax*Bx)+(Ay*By)+(Az*Bz). The result of the dot product may be in the range from 0 to 1. To scale the result of the dot product in the range from −1 and 1, the result may be multiplied by 2 and then 1 may be subtracted: ((2Ax−1)*Bx)+((2Ay−1)*By)+((2Az−1)*Bz), where Axyz is the unpacked vector A and B is the tangent space conversion matrix. Mathematically, the scaled result is equal to (2Ax Bx−Bx)+(2AyBy−By)+(2AzBz−Bz). The initial stage 206 may select the appropriate operands of the contents of registers 220-221 to enable the graphics pipeline 202 to calculate and output the scaled result.

For example, in the first lane 234, the multiplier unit 254 may receive the words Ax and Bx from the mux units 240-241, compute 2A×Bx, and provide the result to the adder 260. To illustrate, the multiplier unit 254 may compute A×Bx and then increment the exponent of the resulting floating point number to compute 2A×Bx. The aligner unit 250 may align the word Bx for a subtraction operation and provide the result to the adder unit 260. The aligner unit 250 may align the word Bx substantially at the same time (i.e., in parallel) that the multiplier unit 254 computes 2A×Bx. The adder unit 260 may receive 2A×Bx from the multiplier unit 254, receive Bx from the aligner unit 250, and compute 2A×Bx−Bx.

In the second lane 235, the multiplier unit 255 may receive the words Ay and By from the mux units 242-243, compute 2AyBy, and provide the result to the adder 261. The aligner unit 251 may align the word By for a subtraction operation and provide the result to the adder unit 261. The aligner unit 251 may align the word By substantially at the same time (i.e., in parallel) that the multiplier unit 255 computes 2AyBy. The adder unit 261 may receive 2AyBy from the multiplier unit 255, receive By from the aligner unit 251, and subtract By from 2AyBy (i.e., compute 2AyBy−By).

In the third lane 236, the multiplier unit 256 may receive the words Az and Bz from the mux units 244-245, compute 2AzBz, and provide the result to the adder 262. The aligner unit 252 may align the word Bz for a subtraction operation and provide the result to the adder unit 262. The aligner unit 252 may align the word Bz substantially at the same time (i.e., in parallel) that the multiplier unit 256 computes 2AzBz. The adder unit 262 may receive 2AzBz from the multiplier unit 256, receive Bz from the aligner unit 252, and compute 2AzBz−Bz.

To compute the scaled dot product, the results from each of the lanes 234-236 may be summed. The output of the adder units 260-262 may be sent to summing stage 204, bypassing the normalize units 264-267 and the rounding units 270-273. The aligner units 280-282 may receive the results of calculating 2AxBx−Bx, 2AyBy−By, and 2AzBz−Bz from the adder units 260-262, respectively. The aligner units 280-282 may align the results of calculating 2AxBx−Bx, 2AyBy−By, and 2AzBz−Bz to enable the 4:2 compressor unit 284 to add two pairs of numbers to produce a pair of numbers. Because the fourth lane 237 is not used, the 4:2 compressor unit 284 may determine the result of (2AxBx−Bx+2AyBy−By) and (2AzBz−Bz+0). The adder unit 285 may take the results of the 4:2 compressor unit 284 and add the two numbers together to produce the scaled dot product result of 2AxBx−Bx+2AyBy−By+2AzBz−Bz.

The normalize unit 286 may normalize the result of the adder unit 285 and store the result in the register file 208. For example, the normalize unit 286 may convert the result of the adder unit 285 from a floating point number to an integer equivalent and store the integer equivalent in a result register (not shown) of the register file 208.

The result of the normalize unit 286 is the dot product of vector A with vector B (i.e., a row of a transformation matrix). The dot product of vector A and vector B is a first entry of the vector A mapped to camera space from tangent space. To calculate the transformation of the vector A from tangent space to camera space, the dot product of each row of the transformation matrix with the vector A may be calculated. Thus, to transform the vector A from tangent space to camera space, the vector A may be loaded into the register 220, the first row of the transformation matrix may be loaded into the register 221, the dot product of vector A with the first row of the transformation matrix may be computed (e.g., using the initial stage 206, the graphics pipeline 202, and the summing stage 204), and the process repeated for each of the other two rows of the transformation matrix.

B₁₁B₁₂B₁₃A_(x)   A_(x)B₁₁ + A_(y)B₁₂ + A_(z)B₁₃ B₂₁B₂₂B₂₃A_(y) = A_(x)B₂₁ + A_(y)B₂₂ + A_(z)B₂₃ B₃₁B₃₂B₃₃A_(z)   A_(x)B₃₁ + A_(y)B₃₂ + A_(Z)B₃₃

In the above example, in the first pass through the initial stage 206, the graphics pipeline 202, and the summing stage 204, B₁₁, B₁₂, B₁₃ may correspond to Bx, By, and Bz, respectively, that are stored in the register 221. In the second pass through, B₂₁, B₂₂, B₂₃ may correspond to Bx, By, and Bz, that are stored in the register 221. In the third pass, B₃₁, B₃₂, B₂₃ may correspond to Bx, By, and Bz, that are stored in the register 221.

Thus, by adding the unpack unit 212 and the mux units 240-247 before the graphics pipeline 202, each word of the vector A (i.e., Ax, Ay, and Az) may be unpacked as floating point numbers and selected as operands to perform a dot product operation and a scaling operation. The dot product operation and scaling operation may be performed without having to write any intermediate results to the register file 208, thereby reducing the number of clock (or processor) cycles used to calculate the scaled result of the dot product operation.

Referring now to FIG. 3, a first flow diagram of a method to calculate a scaled dot product is depicted and generally designated 300. The method 300 may be performed by an initial stage, such as the unpack unit 112 and the mux units 110 of FIG. 1 or the initial stage 206 of FIG. 2.

The method 300 begins when packed data corresponding to pixel components to be processed at a graphics pipeline is received, at 302. Moving to 304, the packed data is unpacked to generate floating point numbers that correspond to the pixel components. For example, in FIG. 2, the unpack unit 212 may unpack the words Ax, Ay, and Az stored in the register 220 to generate floating point numbers that correspond to Ax, Ay, and Az.

Moving to 306, each of the floating point numbers is routed to a separate lane of the graphics pipeline. Each of the floating point numbers is processed by a multiplier unit of the graphics pipeline. Advancing to 308, second floating point numbers may be routed to aligner units of the graphics pipeline and the method 300 ends. The aligner units may align the second floating point numbers for a subtraction operation. For example, in FIG. 2, the mux units 240-247 may route the floating point numbers generated by the unpack unit 212 to the multipliers 254-257 of the graphics pipeline 202. The mux units 240-247 may route the second floating numbers (e.g., Bx, By, Bz, and Bw) that are stored in register 221 to the multiplier units 254-257 and to the aligner units 250-253.

Thus, an unpack unit may be used to unpack packed data that represents a pixel to generate floating point numbers. Mux units may route the floating point numbers and second floating point numbers (e.g., entries in a row of a conversion matrix) to a graphics pipeline. Multiplier units of the graphics pipeline may multiply the floating point numbers with the second floating point numbers. Adder units of the graphics pipeline may subtract the second floating point numbers from the result of multiplying the floating point numbers with the second floating point numbers to produce scaled floating point numbers. The scaled floating point numbers may be summed to produce a scaled dot product of the floating point numbers with the second floating point numbers. For example, the floating point numbers may represent a normal vector in tangent space, the second floating point numbers may represent a row of a tangent space conversion matrix, and the scaled dot product may represent an entry of the mapped vector in camera space.

Referring now to FIG. 4, a second flow diagram of a method to calculate a scaled dot product is depicted and generally designated 400. The method 400 may be performed by the system 100 of FIG. 1 or by the system 200 of FIG. 2.

The method 400 begins when packed data corresponding to pixel components to be processed at a graphics pipeline are received, at 402. Moving to 404, a mapping instruction is received. Advancing to 406, in response to receiving the mapping instruction, the packed data is unpacked to generate first floating point numbers that correspond to the pixel components. For example, in FIG. 2, in response to receiving the NMAP instruction 214, the unpack unit 212 may unpack the contents of register 220 to generate first floating point numbers that correspond to red, green, and blue pixel components.

Proceeding to 408, each of the first floating point numbers are routed to a separate lane of the graphics pipeline via a set of muxes. Each of the first floating point numbers is processed by a multiplier unit of the graphics pipeline. Continuing to 410, each of second floating point numbers may be routed to the separate lanes of the graphics pipeline via the set of muxes. Each of the second floating point numbers is processed by an aligner unit of the graphics pipeline. For example, in FIG. 2 the mux units 240-247 may send first floating point numbers (i.e., the unpacked contents of the register 220) to the multiplier units 254-257. The mux units 240-247 may send second floating point numbers (i.e., the contents of the register 221) to the multiplier units 254-257 and to the aligners 250-253.

Moving to 412, the first floating point numbers may be multiplied with the second floating point numbers at the multiplier units. For example, in FIG. 2, the multiplier unit 254 may multiply 2Ax with Bx, the multiplier unit 255 may multiply 2Ay with By, and the multiplier unit 254 may multiply 2Az with Bz. Advancing to 414, the results of multiplying the first floating point numbers with the second floating point numbers may be routed to adder units of the graphics pipeline. Continuing to 416, the adder units may subtract aligned second floating point numbers from the results of multiplying the first floating point numbers with the second floating point numbers to produce scaled floating point numbers. For example, in FIG. 2, the adder unit 260 may subtract Bx from 2A×Bx (i.e., the result from the multiplier unit 254), the adder unit 261 may subtract By from 2AyBy (i.e., the result from the multiplier unit 255), and the adder unit 262 may subtract Bz from 2AzBz (i.e., the result from the multiplier unit 256).

Moving to 418, the scaled floating point numbers may be summed together at a summing stage to produce a scaled dot product of the first floating point numbers with the second floating point numbers and the method 400 ends. For example, in FIG. 2, the summing stage 204 may sum (2AxBx−Bx), (2AyBy−By), and (2AzBz−Bz) to produce a scaled dot product of the unpacked vector A with the vector B.

Thus, an unpack unit may be used to unpack packed data that represents a pixel to generate floating point numbers. Mux units may route the floating point numbers and second floating point numbers (e.g., entries in a row of a conversion matrix) to a graphics pipeline. Multiplier units of the graphics pipeline may multiply the floating point numbers with the second floating point numbers. Adder units of the graphics pipeline may subtract the second floating point numbers from the result of multiplying the floating point numbers with the second floating point numbers to produce scaled floating point numbers. The scaled floating point numbers may be summed to produce a scaled dot product of the floating point numbers with the second floating point numbers. For example, the floating point numbers may represent a normal vector in tangent space, the second floating point numbers may represent a row of a tangent space conversion matrix, and the scaled dot product may represent a component of the normal vector transformed into camera space.

FIG. 5 is a block diagram of a computing system in which systems and methods of the present disclosure may be implemented. Computing system 500 includes an a graphics processing unit 510 that may be used to perform a scaled dot product operation.

In the depicted example, the computing system 500 employs a hub architecture including a north bridge and a memory controller hub (MCH) 502 and a south bridge and input/output (I/O) controller hub (ICH) 504. A processor 506, a main memory 508, and the graphics processing unit 510 are coupled to the north bridge and memory controller hub 502. For example, the graphics processing unit 510 may be coupled to the MCH 502 through an accelerated graphics port (AGP) (not shown).

The graphics processing unit 510 may include an initial stage 546, a graphics pipeline 548, and a summing stage 550. For example, the initial stage 546 may include an unpack unit (now shown) and mux units (not shown), similar to the initial stage 206 of FIG. 2. The graphics pipeline 548 may include aligner units (not shown), multiplier units (not shown), and adder units (not shown), similar to the graphics pipeline 202 of FIG. 2. The summing stage 550 may include aligner units, compressor units, adder units, and normalize units, similar to the summing stage 204 of FIG. 2.

In the depicted example, a network adapter 512 is coupled to the south bridge and I/O controller hub 504 and an audio adapter 516, a keyboard and mouse adapter 520, a modem 522, a read only memory (ROM) 524, universal serial bus (USB) ports and other communications ports 532, and Peripheral Component Interconnect (PCI) and Peripheral Component Interconnect Express (PCIe) devices 534 are coupled to the south bridge and I/O controller hub 504 via bus 538. A disk drive 526 and a CD-ROM drive 530 are coupled to the south bridge and I/O controller hub 504 through the bus 538. The PCl/PCIe devices 534 may include, for example, Ethernet adapters, add-in cards, and PC cards for notebook computers. The ROM 524 may be, for example, a flash binary input/output system (BIOS). The disk drive 526 and the CD-ROM drive 530 may use, for example, an integrated drive electronics (IDE) or serial advanced technology attachment (SATA) interface. A super I/O (SIO) device 536 may be coupled to the south bridge and I/O controller hub 504.

The main memory 508 includes computer instructions 544 on a computer readable medium. The computer instructions 544 are executable by the processor 506 or the graphic processing unit 510 to perform various functions.

An operating system (not shown) runs on the processor 506 and coordinates and provides control of various components within the computing system 500. The operating system may be a commercially available operating system such as Microsoft® Windows® XP (Microsoft and Windows are trademarks of Microsoft Corporation in the United States, other countries, or both). An object oriented programming system, such as the Java® programming system, may run in conjunction with the operating system and provide calls to the operating system from Java programs or applications executing on the computing system 500 (Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both).

Instructions for the operating system, the object-oriented programming system, and applications or programs are located on storage devices, such as the disk drive 526, and may be loaded into the main memory 508 for execution by the processor 506. The processes of the disclosed illustrative embodiments may be performed by the processor 506 using computer implemented instructions, which may be located in a non-transitory memory such as, for example, the main memory 508, the read only memory 524, or in one or more of the peripheral devices.

The hardware in computing system 500 may vary depending on the implementation. Other internal hardware or peripheral devices, such as flash memory, equivalent non-volatile memory, or optical disk drives and the like, may be used in addition to or in place of the hardware depicted in FIG. 5. Also, the processes of the disclosed illustrative embodiments may be applied to a multiprocessor data processing system.

In some illustrative examples, portions of the computing system 500 may be implemented in a personal digital assistant (PDA), which is generally configured with flash memory to provide non-volatile memory for storing operating system files and/or user-generated data. A bus system may include one or more buses, such as a system bus, an I/O bus and a PCI bus. Of course, the bus system may be implemented using any type of communications fabric or architecture that provides for a transfer of data between different components or devices attached to the fabric or architecture. A communications unit may include one or more devices used to transmit and receive data, such as a modem or a network adapter. A memory may be, for example, the main memory 508 or a cache such as found in the north bridge and memory controller hub 502. A processing unit may include one or more processors or CPUs, such as the processor 506 or the graphics processing unit 510. The depicted examples in FIG. 5 and above-described examples are not meant to imply architectural limitations. For example, portions of the computing system 500 also may be implemented in a personal computer, server, server cluster, tablet computer, laptop computer, or telephone device in addition to taking the form of a PDA.

Particular embodiments of the computing system 500 can take the form of an entirely hardware embodiment or an embodiment containing both hardware and software units. In a particular embodiment, the disclosed methods are implemented in software that is embedded in processor readable non-transitory medium and executed by a processor, which includes but is not limited to firmware, resident software, microcode, etc.

Further, embodiments of the present disclosure, such as the one or more embodiments in FIGS. 1-5 can take the form of a computer program product accessible from a computer-usable or computer-readable medium providing program code for use by or in connection with a computer or any instruction execution system. For the purposes of this description, a non-transitory computer-usable or computer-readable medium can be any non-transitory medium that can tangibly embody a computer program and that can contain or store the computer program for use by or in connection with the instruction execution system, apparatus, or device.

In various embodiments, the medium can include an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system (or apparatus or device) or a propagation medium. Examples of a computer-readable medium include a semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk and an optical disk. Current examples of optical disks include compact disk-read only memory (CD-ROM), compact disk-read/write (CD-R/W) and digital versatile disk (DVD).

A data processing system suitable for storing and/or executing program code may include at least one processor coupled directly or indirectly to memory units through a system bus. The memory units can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code in order to reduce the number of times code must be retrieved from bulk storage during execution.

Input/output or I/O devices (including but not limited to keyboards, displays, pointing devices, etc.) can be coupled to the data processing system either directly or through intervening I/O controllers.

Network adapters may also be coupled to the data processing system to enable the data processing system to become coupled to other data processing systems or remote printers or storage devices through intervening private or public networks. Modems, cable modems, and Ethernet cards are just a few of the currently available types of network adapters.

The previous description of the disclosed embodiments is provided to enable any person skilled in the art to make or use the disclosed embodiments. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other embodiments without departing from the scope of the disclosure. Thus, the present disclosure is not intended to be limited to the embodiments shown herein but is to be accorded the widest scope possible consistent with the principles and features as defined by the following claims. 

1. A method, comprising: receiving packed data corresponding to pixel components to be processed at a graphics pipeline; unpacking the packed data to generate floating point numbers that correspond to the pixel components; and routing each of the floating point numbers to a separate lane of the graphics pipeline, each of the floating point numbers to be processed by a multiplier unit of the graphics pipeline.
 2. The method of claim 1, wherein the unpacking and the routing are performed in response to receiving a mapping instruction.
 3. The method of claim 1, further comprising routing second floating point numbers to the multiplier units and to aligner units of the graphics pipeline, the aligner units to align the second floating point numbers for a subtraction operation.
 4. The method of claim 3, wherein the multiplier units are operable to multiply the floating point numbers with the second floating point numbers and to route the results to adder units of the graphics pipeline.
 5. The method of claim 4, wherein the adder units are operable to subtract the aligned second floating point numbers from the results of multiplying the floating point numbers with the second floating point numbers to produce scaled floating point numbers.
 6. The method of claim 5, wherein the scaled floating point numbers are summed together to produce a scaled dot product of the floating point numbers with the second floating point numbers.
 7. The method of claim 6, wherein the scaled dot product is produced without writing intermediate results from the multiplier units, the aligner units, and the adder units to a register file.
 8. The method of claim 1, wherein routing each of the floating point numbers is performed by a plurality of mux units.
 9. A method, comprising: receiving packed data corresponding to pixel components to be processed at a graphics pipeline; receiving a mapping instruction; in response to receiving the mapping instruction, unpacking the packed data to generate first floating point numbers that correspond to the pixel components; routing each of the first floating point numbers to a separate lane of the graphics pipeline via a set of mux units, each of the first floating point numbers to be processed by a multiplier unit of the graphics pipeline; and routing each of second floating point numbers to the separate lanes of the graphics pipeline via the set of mux units, each of the second floating point numbers to be processed by an aligner unit of the graphics pipeline.
 10. The method of claim 9, further comprising: multiplying the first floating point numbers with the second floating point numbers at the multiplier units; and routing the results of multiplying the first floating point numbers with the second floating point numbers to adder units of the graphics pipeline.
 11. The method of claim 10, further comprising: subtracting, at the adder units, the aligned second floating point numbers from the results of multiplying the first floating point numbers with the second floating point numbers to produce scaled floating point numbers.
 12. The method of claim 11, further comprising summing the scaled floating point numbers together at a summing stage to produce a scaled dot product of the first floating point numbers with the second floating point numbers.
 13. The method of claim 12, wherein the scaled for product of the first floating point numbers with the second floating point numbers is produced in no more than fourteen clock cycles.
 14. A system, comprising: an unpack unit to receive packed data corresponding to pixel components and to unpack the packed data to generate floating point numbers that correspond to the pixel components, the pixel components including a red component, a green component, and a blue component; and a first plurality of mux units to selectively route each of the floating point numbers to a separate lane of a graphics pipeline, the floating point numbers to be processed by multiplier units of the graphics pipeline.
 15. The system of claim 14, wherein the unpack unit is operable to unpack the packed data in response to receiving a mapping instruction.
 16. The system of claim 15, further comprising a second plurality of mux units to selectively route second floating point numbers to aligner units of the graphics pipeline, the aligner units to align the second floating point numbers for a subtraction operation.
 17. The system of claim 16, wherein the multiplier units are operable to multiply the floating point numbers with the second floating point numbers and to route the results to adder units of the graphics pipeline.
 18. The system of claim 17, wherein the adder units are operable to subtract the aligned second floating point numbers from the results of multiplying the floating point numbers with the second floating point numbers to produce scaled floating point numbers.
 19. The system of claim 18, further comprising a summing stage to sum the scaled floating point numbers to produce a scaled dot product of the floating point numbers with the second floating point numbers.
 20. The system of claim 14, wherein the floating point numbers represent a vector in tangent space, wherein the second floating point numbers represent a row of a transformation matrix. 